home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 04 - 1988 / 04.11 Nov 88 / fast rotate source / rotate.a < prev    next >
Encoding:
Text File  |  1988-05-18  |  11.8 KB  |  390 lines  |  [TEXT/MPS ]
  1.     INCLUDE    'SysEqu.a'    ;the usual system equates & macros    
  2.     INCLUDE    'Traps.a'
  3.     INCLUDE    'QuickEqu.a'
  4.     
  5. newPtrClear FUNC EXPORT
  6.     
  7.     IMPORT    SAVERETA1
  8.     
  9.     MOVE.L    (SP)+,A1
  10.     MOVE.L    (SP)+,D0
  11.     _NewPtr    clear
  12.     MOVE.L    A0,(SP)
  13.     JMP    SAVERETA1
  14.     
  15.     ENDF
  16.  
  17.  
  18. Rotate PROC EXPORT
  19. ;------------------------------------------------------------------------
  20. ;    
  21. ; PROCEDURE    Rotate (sourceMap, destMap : bitMap );
  22. ;    
  23. ; given a source and destination bitmap rotate it CCW 90°…
  24. ; bitmap can be of any size, we will align on a word boundaries (v & h)
  25. ;
  26. ;-------------------------------------------------------------------------------
  27. ;    a0 = result of _newPtr call            |    d0 = size of bitMap to allocate
  28. ;    a1 = ptr to src bitMap                |    d1 = width/2  (source)
  29. ;    a2 = ptr to dest bitMap                |    d2 = height/2 (source)
  30. ;    a3 = dest bits                        |    d3 = left | top
  31. ;    a4 = copy of dest bits                |    d4 = ctrPt.h
  32. ;    a5 = not used                        |    d5 = ctrPt.v
  33. ;    a6 = not used                        |    d6 = right | bottom
  34. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  35. ;-------------------------------------------------------------------------------
  36. ; ***********************************************************************
  37. ; *                                                                        *
  38. ; *        Initialize destination bitMap (destMap), etc…                    *
  39. ; *                                                                        *
  40. ; ***********************************************************************
  41. ; parameter offsets
  42. ;
  43. DestMap        EQU    4+4                ; offset to dest bitmap ^
  44. SourceMap    EQU DestMap + 4        ; offset to source bitmap ^
  45. ;
  46. ; create local stack frame, and save some registers
  47. ; make room for dest rect to be passed back
  48. ;
  49.     link    a6,#0                ; set up a stack frame (no bytes)
  50.     movem.l    d3-d7/a2-a5,-(sp)    ; save registers pascal may need
  51.  
  52.     move.l    SourceMap(a6),a1    ; point to the source BitMap
  53.     move.l    DestMap(a6),a2        ; point to the dest BitMap
  54. ;
  55. ; compute height of source BitMap rounded up to nearest word
  56. ;                                
  57.     move.w    bounds+bottom(a1),d7; get bottom and put in d7
  58.     sub.w    bounds+top(a1),d7    ; bottom - top = height, put in d7
  59.     move.w    d7,d0                ; save a copy of height for later
  60.                                 ; rnd = (height+15)/16, follows:
  61.     addi.w    #15,d7                ; add 15 to the height, put in d7
  62.     lsr        #4,d7                ; divide by 16
  63.     lsl        #1,d7                ; multiply by 2 = rowBytes of dest bitMap
  64. ;
  65. ; d7 now contains rowBytes of dest bitMap
  66. ;
  67. ; now compute the destRect for dest bitMap
  68. ;
  69.                                 ; compute center point of Source rect
  70.                                 ; note the center points are not necess. the
  71.                                 ; same in the vert dir. relative to srcMap
  72.                                 ; because of rounding that follows (i.e. height
  73.                                 ; of srcMap is dir. prop. to RowBytes of destMap)
  74.     lsr        #1,d0                ; divide height by 2
  75.     move.w    d0,d2                ; make a copy of height/2 for later
  76.     move.w    bounds+top(a1),d5    ; get 'top' of source rect
  77.     add.w    d0,d5                ; d5 now contains vert component of ctr pt
  78.                                 ; compute the width of src rect & put in d4
  79.     move.w    bounds+right(a1),d3    ; get right and put in d3
  80.     sub.w    bounds+left(a1),d3    ; right - left = width, put in d3
  81.     lsr        #1,d3                ; divide width by 2
  82.     move.w    d3,d1                ; make a copy of width/2 for later
  83.     move.w    bounds+right(a1),d4    ; get right of source rect
  84.     sub.w    d3,d4                ; d4 now contains horiz component of ctr pt
  85. ;
  86. ; now get center point and compute bounds for dest bitMap
  87. ; height and width are reversed now for the 2 bitMaps
  88. ;
  89. ; left    :=ctrPt.h - height/2
  90. ; top    :=ctrPt.v - width/2
  91. ; right    :=ctrPt.h + height/2
  92. ; bottom:=ctrPt.v + width/2
  93. ; SetRect(rect, left, top, right, bottom) put data in direct to
  94. ; avoid the overhead of a trap call
  95. ;
  96.                                 ; compute 'top'
  97.     move.w    d5,d3                ; get a copy of ctrPt.v and put in d3
  98.     sub.w    d1,d3                ; ctrPt.v - width/2 = 'top' in d3
  99.     swap    d3                    ; move 'top' to hiword
  100.                                 ; compute 'left'
  101.     move.w    d4,d3                ; get a copy of ctrPt.h and put in loword d3
  102.     sub.w    d2,d3                ; ctrPt.h - height/2 = 'left' in loword d3
  103. ;
  104. ; we now have 'top' in hiword & 'left' in loword d3
  105. ;
  106.                                 ; compute 'bottom'
  107.     move.w    d5,d6                ; get a copy of ctrPt.v in of d3
  108.     add.w    d1,d6                ; ctrPt.v + width/2 = 'bottom' in d3
  109.     swap    d6                    ; move 'bottom' to hiword    
  110.                                 ; compute 'right'
  111.     move.w    d4,d6                ; get a copy of ctrPt.h and put in loword d6
  112.     add.w    d2,d6                ; ctrPt.h + height/2 = 'right' in loword d6
  113. ;
  114. ; we now have 'bottom' in hiword & 'right' in loword d6
  115. ;
  116. ; assign data to dest bitMap structure directly
  117. ;
  118.     move.w    d7,rowBytes(a2)        ; put in rowBytes direct for dest bitMap
  119.     move.l    d3,bounds+topLeft(a2)    ; put the coord pair in direct
  120.     move.l    d6,bounds+botRight(a2)    ; put the coord pair in direct
  121.     move.w    d7,d0                ; put rowbytes in d0
  122.     mulu    rowBytes(a1),d0        ; multiply rowBytes src*dest = d0
  123.     lsl        #3,d0                ; multiply d0 by 8 for size of dest bitMap
  124.     _NewPtr    clear                ; allocate size of dest bitMap (a2 pts to it) 
  125.     move.l    a0,baseaddr(a2)        ; move contents of a0 to baseAddr field
  126.                                 ; of dest bitMap structure
  127.                                 
  128. ;-------------------------------------------------------------------------------
  129. ;    a0 = baseAddr for our locals        |    d0 = rowbytes of srcMap
  130. ;    a1 = points to bits of src bitMap    |    d1 = width/2     (source)
  131. ;    a2 = ptr to dest bitMap                |    d2 = height/2      (source)
  132. ;    a3 = dest bits                        |    d3 = current word srcMap
  133. ;    a4 =                                 |    d4 = copy of width of srcMap
  134. ;    a5 = not used                        |    d5 = current destMap word
  135. ;    a6 = not used                        |    d6 = insideLoop count (current bit)
  136. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  137. ;-------------------------------------------------------------------------------
  138. ; ***********************************************************************
  139. ; *                                                                        *
  140. ; *        Start actual rotation of bitMaps                                *
  141. ; *                                                                        *
  142. ; ***********************************************************************
  143. ; Assumptions:
  144. ; height of destination bitMap = rowBytes of srcMap
  145. ;
  146. ; 
  147. ; Get the baseAddr for our locals into a0 - this will make our program much
  148. ; more readable as we will let the assembler do all the addr location calcs
  149. ; for us. The addresses will be a fixed number while the programs is
  150. ; (locked down) and running, therefore, there is no runtime penalty for
  151. ; doing this addr calculation
  152. ;
  153.  
  154.     lea    localVars,a0
  155.  
  156.     ; Synchronize with the TickCount rollover.
  157.     move.l    ticks, d0            ; get the time
  158. @1    cmp.l    ticks, d0            ; changed yet?
  159.     beq.s    @1                    ; nope: loop
  160.  
  161.     ; Strobe the starting time.
  162.     move.l    ticks, startTime-localVars(a0) ; save starting time, in ticks
  163.  
  164. ;
  165. ; initialize d0 to contain the pointer to the srcMap
  166. ;
  167.     move.w    rowbytes(a1),d0        ; get rowbytes of srcMap
  168.     
  169. ;
  170. ; get regs pointing to bits
  171. ;
  172.     move.l    (a1),a1                ; a1 pts to BITS of src bitMap    
  173.     move.l    (a2),a3                ; a3 pts to BITS of dest bitMap
  174.  
  175. ; 
  176. ; compute the lower left corner of the destMap - this maps to the upper left
  177. ; corner of the srcMap and will be used as base from which to offset into
  178. ; the dest map when we need to set a bit
  179. ;
  180.     clr.l    d1                    ; clear d1 
  181.     move.w    d0,d1                ; load rowBytes of srcMap
  182.                                 ; (rowBytes of srcMap = ht of destMap)
  183.     lsl.w    #3,d1                ; multiply by 8 to get ht of destMap when rot'd
  184.     mulu.w    d7,d1                ; multiply by rowbytes(destMap) = #words in
  185.     sub.w    d7,d1                ; destMap less one row
  186.     add.l    a3,d1                ; add the computed offset to the baseAddr of destMap
  187.     move.l    d1,lowerLeft-localVars(a0)    ; init lowerLeft
  188. ;
  189. ;-------------------------------------------------------------------------------
  190. ;    a0 = baseAddr for our locals        |    d0 = rowbytes of srcMap
  191. ;    a1 = points to bits of src bitMap    |    d1 = SCRATCH
  192. ;    a2 = SCRATCH                        |    d2 = colmCounter
  193. ;    a3 = dest bits                        |    d3 = current srcMap word 
  194. ;    a4 = SCRATCH                        |    d4 = colmBitLoop counter
  195. ;    a5 = not used                        |    d5 = current word destMap
  196. ;    a6 = not used                        |    d6 = insideLoop count (current bit)
  197. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  198. ;-------------------------------------------------------------------------------
  199. ;
  200.  
  201. ;    _Debugger;
  202.     
  203. ; init wordCount to zero 
  204. ;
  205.     move.w    #0,wordCount-localVars(a0)    ; set wordCount to one before we start
  206. ;
  207. ; init colmLoop counter
  208. ;
  209.     move.w    d7,d2                ; get rowBytes(dest)
  210.     lsr        #1,d2                ; divide by 2 - d2 now contains the outer counter
  211.     move.w    d2,colmCount-localVars(a0)    ; put the max value away for reference
  212.     moveq.l    #0,d2                ; set d2 to zero since we use it for the counter
  213.  
  214. colmLoop
  215. ;
  216. ; this is the outside loop
  217. ;
  218.     move.w    #15,d4                ; init colmBitLoop counter to 15
  219.     move.l    lowerLeft-localVars(a0), a2    ; init currentWord    
  220.  
  221. colmBitLoop
  222. ;
  223. ; this is the loop that does the bit counting in the destMap - it is really a
  224. ; misuse of the 'dbra' instruction since it is not an independent loop but it
  225. ; is a quite cheap method of doing our counting
  226. ;
  227.  
  228.     cmp.w    #7, d4                        ; are we doing high byte or low?
  229.     bgt        dobyte1                        ; skip if high byte
  230.     addq    #1, a2                        ; else point to low byte
  231. dobyte1
  232.  
  233. rowLoop
  234. ;
  235. ; loop across each row in the srcMap and keep count each time we do a row
  236. ; this 'rowCount' will used to compute the offset from 'lowerLeft'
  237. ;
  238.     move.w    (a1)+, d3                    ; get a word to rotate into d3
  239.     addq.w    #2,wordCount-localVars(a0)    ; add 1 for each word •••jdo•••
  240.     
  241.     add.w    d3, d3                        ; test next bit in the current source word
  242.     bcc.s    NoBitToChange                ; if bit’s not set, skip to next
  243.     bset    d4, (a2)                    ; set proper bit in high or low byte in currentWord
  244. noBitToChange
  245.     sub.l    d7, a2                        ; subtract rowBytes(destMap) from current word
  246.  
  247.     ; Do the same as above, fifteen more times.
  248.     add.w    d3, d3
  249.     bcc.s    @1
  250.     bset    d4, (a2)
  251. @1    sub.l    d7, a2
  252.  
  253.     add.w    d3, d3
  254.     bcc.s    @2
  255.     bset    d4, (a2)
  256. @2    sub.l    d7, a2
  257.  
  258.     add.w    d3, d3
  259.     bcc.s    @3
  260.     bset    d4, (a2)
  261. @3    sub.l    d7, a2
  262.  
  263.     add.w    d3, d3
  264.     bcc.s    @4
  265.     bset    d4, (a2)
  266. @4    sub.l    d7, a2
  267.  
  268.     add.w    d3, d3
  269.     bcc.s    @5
  270.     bset    d4, (a2)
  271. @5    sub.l    d7, a2
  272.  
  273.     add.w    d3, d3
  274.     bcc.s    @6
  275.     bset    d4, (a2)
  276. @6    sub.l    d7, a2
  277.  
  278.     add.w    d3, d3
  279.     bcc.s    @7
  280.     bset    d4, (a2)
  281. @7    sub.l    d7, a2
  282.  
  283.     add.w    d3, d3
  284.     bcc.s    @8
  285.     bset    d4, (a2)
  286. @8    sub.l    d7, a2
  287.  
  288.     add.w    d3, d3
  289.     bcc.s    @9
  290.     bset    d4, (a2)
  291. @9    sub.l    d7, a2
  292.  
  293.     add.w    d3, d3
  294.     bcc.s    @10
  295.     bset    d4, (a2)
  296. @10    sub.l    d7, a2
  297.  
  298.     add.w    d3, d3
  299.     bcc.s    @11
  300.     bset    d4, (a2)
  301. @11    sub.l    d7, a2
  302.  
  303.     add.w    d3, d3
  304.     bcc.s    @12
  305.     bset    d4, (a2)
  306. @12    sub.l    d7, a2
  307.  
  308.     add.w    d3, d3
  309.     bcc.s    @13
  310.     bset    d4, (a2)
  311. @13    sub.l    d7, a2
  312.  
  313.     add.w    d3, d3
  314.     bcc.s    @14
  315.     bset    d4, (a2)
  316. @14    sub.l    d7, a2
  317.  
  318.     add.w    d3, d3
  319.     bcc.s    @15
  320.     bset    d4, (a2)
  321. @15    sub.l    d7, a2
  322.  
  323. ;
  324. ; at this point we've just completed a word from the srcMap
  325. ;
  326.     cmp        wordCount-localVars(a0),d0        ; cmp wordCount to rowBytes-are we done with a row ?
  327.     bne        rowLoop                            ; no - do another word
  328.     
  329.     cmp.w    #7, d4                        ; did we do high byte or low?
  330.     bgt        dobyte2                        ; skip if high byte
  331.     subq    #1, a2                        ; else undo the fudge to a2
  332. dobyte2
  333.  
  334. ;
  335. ; we just completed a row so add 2 to the count
  336. ;
  337.     move.w    #0,wordCount-localVars(a0)        ; •••jdo••• reset wordCount to zero
  338.  
  339. ;    
  340. ; the following use of dbra keeps track of our destMap bit for us
  341. ;
  342.     move.l    lowerLeft-localVars(a0), a2    ; re-init currentWord    
  343.                                         ; set the currentWord to the lowerLeft(current)
  344.                                         ; lowerLeft is moved over (right) by a word each
  345.                                         ; time we do a row in the srcMap
  346.     dbra    d4,colmBitLoop                ; go thru the bits (15->0) in the
  347.                                         ; destMap - then exit and do it
  348.                                         ; again for rowBytes/2 times
  349.  
  350. ;
  351. ; were done counting thru the bits of a destMap word - at this point we have
  352. ; actually finished a column in the destMap. The column is a multiple of
  353. ; 16 bits wide (and being at least 1 colm) and as tall as the destMap is
  354. ; (which is also equal to rowBytes of the srcMap)
  355. ;
  356.     addq.l    #2,lowerLeft-localVars(a0)        ; this moves us into the next
  357.                                             ; 'column' of bits in the destMap
  358.     addq.w    #1,d2                            ; add 1 to the colmLoop counter
  359.     cmp        colmCount-localVars(a0),d2        ; are we done yet ?
  360.     bne        colmLoop                        ; no - do it again
  361.                                             ; else we're done
  362. ;
  363. ; were done so lets do our clean-up/restore and go away gracefully
  364. ;
  365.     move.l    ticks, d0            ; get the current time…
  366.     sub.l    startTime-localVars(a0), d0 ; …less starting time
  367.     _Debugger                    ; and let me see the time it took
  368.  
  369.     movem.l    (sp)+,d3-d7/a2-a5    ; restore registers
  370.     unlk    a6                    ; clean up stack frame
  371.     move.l    (sp)+,a0            ; return address
  372.     add.l    #8,sp                ; pop parameters off stack
  373.     jmp        (a0)                 ; bye y'all!
  374.     
  375. ;
  376. ; set up our data storage area
  377. ;
  378. localVars                        ; the beginning of our local var storage area
  379. colmCount        ds.w    1
  380. currentWord        ds.l    1
  381. lowerLeft        ds.l    1
  382. wordCount        ds.w    1
  383. startTime        ds.l    1
  384.  
  385.     ENDP
  386.     
  387.     END
  388.     
  389.  
  390.